home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / Drtf / DRichProcess.cpp < prev    next >
Text File  |  1996-07-05  |  10KB  |  494 lines
  1. // DRichProcess.cpp
  2. // d.g.gilbert
  3.  
  4.  
  5. #include "Dvibrant.h"
  6. #include "DFile.h"
  7. #include "DRichProcess.h"
  8. #include "DRichViewNu.h"
  9.  
  10. #define rtfmapInternal
  11. #include "rtfmaps.h"
  12. #undef rtfmapInternal
  13.  
  14.  
  15. // struct StyleRec
  16.  
  17. //static DParagraph     gDefParaFmt;
  18. static StyleRec         gDefaultStyle;
  19. static Nlm_Uint4         gLinkcolor;
  20.  
  21. static char        *kDefaultFontname   = "Courier"; //"Times";
  22. static char        *kDefaultFontfamily = "Modern"; //"Roman";    
  23.  
  24.  
  25. StyleRec::StyleRec()
  26. {
  27.     style = DRichStyle();  // DRichStyle constructor handles !?
  28.     fontname= kDefaultFontname;
  29.     fontfamily= kDefaultFontfamily;
  30.     fontsize= DRichprocess::kDefaultFontsize;
  31. }
  32.  
  33.     
  34.     
  35. DRichprocess::DRichprocess( DFile* itsFile, DRichView* itsDoc, Nlm_MonitorPtr progress) :
  36.     fClass(tokUnknown), fMajor(0), fMinor(0), fParam(0),
  37.     fDataFile( itsFile), fDataBuffer( NULL), fDataSize(0), 
  38.     fDoc(itsDoc), fProgress(progress), fParaCount(0),
  39.     fText(NULL), fTextSize(0), fLastTextSize(0), fTextMax(0),
  40.     fLastChar(0), fPushedChar(EOF), fOutMap(NULL),
  41.     fStyleStackSize(0), fTitle(NULL), fNewStyle(true),
  42.     fEndOfData(false)
  43. { 
  44.     fTextMax= 1024;
  45.     fText= (char*) MemNew(fTextMax+1);
  46.  
  47.     fStyleMax= 5;
  48.     fStyleCount= 0;
  49.     fStyleArray= (DRichStyle*) Nlm_MemNew( fStyleMax*sizeof(DRichStyle));
  50.     fStyleStackSize= 0;
  51.  
  52. #if 0
  53.     fStyleRec.style = DRichStyle();
  54.             // don't need this jazz, constructors handle it
  55.     //DRichStyle    aStyle(false);
  56.     //fStyleRec.style= aStyle;
  57.     //fStyleRec.fontname= kDefaultFontname;
  58.     //fStyleRec.fontfamily= kDefaultFontfamily;
  59.     //fStyleRec.fontsize= kDefaultFontsize;
  60. #endif
  61.     fOldStyleRec= fStyleRec;
  62.     gDefaultStyle= fStyleRec;
  63.     
  64.     (void) GetNlmFont();
  65.     
  66.     // !?? static constructors for DParagraph should do all these !?
  67.     // fParaFmt = DParagraph();
  68.     fParaFmt.deftabstop = kDefTabstop;
  69.     // !?? static constructors for DParagraph should do all these !?
  70.     fOldParaFmt= fParaFmt;
  71.     fDefParaFmt= fParaFmt;
  72.  
  73.         // not for text types ?? (RTF should be ok w/ this...)
  74.     if (fDataFile) {
  75.         ulong fileindex;
  76.         fDataFile->GetDataMark( fileindex);
  77.         fDataFile->Open("rb"); // !!!!! DAMN TEXT TRANSLATION (0d to 0a) WAS SCREWING US UP !!
  78.         fDataFile->SetDataMark( fileindex);
  79.         }
  80. }
  81.  
  82.     
  83. DRichprocess::~DRichprocess()
  84. {
  85.     Close();
  86.     //if (fDataFile) fDataFile->Close(); // caller may do this?
  87.     MemFree(fText);
  88.     MemFree(fStyleArray);
  89.     MemFree(fTitle);
  90.     
  91. }
  92.  
  93. void DRichprocess::SetBuffer( char* dataBuffer, ulong dataSize, Boolean endOfData)
  94. {
  95.     fDataSize= dataSize;
  96.     if (dataSize) fDataBuffer= dataBuffer;
  97.     else fDataBuffer= NULL; // prevent GetOneChar trying to read when no data !
  98.     fEndOfData= endOfData;
  99. }
  100.  
  101. void DRichprocess::Read()
  102. {
  103.     while (GetToken() != tokEOF) 
  104.         RouteToken();
  105.     Close();
  106. }
  107.  
  108. void DRichprocess::Close()
  109. {
  110.     if (fTextSize>0) {
  111.         PutLitCharWithStyle('\n');
  112.         NewParagraph(); /* push last text into doc */
  113.         }
  114.     if (fProgress && fDataFile) {
  115.         long fat= fDataFile->Tell();
  116.         if (fat>0) (void) Nlm_MonitorIntValue(fProgress, fat);
  117.         }
  118. }
  119.  
  120.  
  121. short DRichprocess::GetOneChar()
  122. {
  123.     short    c;
  124.  
  125.     if (fDataBuffer) {
  126.         c= (unsigned char) *fDataBuffer; // must be unsigned !!
  127.         if (fDataSize) {    // for counted data
  128.             fDataSize--;
  129.             fDataBuffer++;
  130.             if (!fDataSize) fDataBuffer= NULL; //  so EOF next time
  131.             }
  132.         else if (c) fDataBuffer++; // for null-term data
  133.         else if (!fEndOfData) c= tokBreakInData;
  134.         else c= EOF;
  135.         }
  136.     else if (fDataFile) 
  137.         c = fgetc( fDataFile->fFile);
  138.     else {
  139.         if (!fEndOfData) c= tokBreakInData;
  140.         else c= EOF;
  141.         }
  142.     return (c);
  143. }
  144.  
  145.  
  146. void DRichprocess::Pushback(char c) // private
  147. {
  148.     if (c != EOF) {
  149.         fPushedChar = c;
  150.         }
  151. }
  152.  
  153.  
  154. void DRichprocess::RouteToken()
  155. {
  156.     switch( fClass ) {
  157.         case tokUnknown:  
  158.             handleUnknownClass(); 
  159.             break;
  160.         case tokText: 
  161.             handleTextClass(); 
  162.             break;
  163.         case tokControl:  
  164.             handleControlClass(); 
  165.             break;
  166.         default:
  167.             //RTFPanic ("Unknown class %d: %s ", fClass, fTokenBuf);
  168.             break;
  169.         }    
  170. }
  171.  
  172. short DRichprocess::GetToken()
  173. {
  174.     do GetToken1(); 
  175.     while (fClass == tokDropchar);
  176.     return (fClass);
  177. }
  178.  
  179.  
  180. void DRichprocess::GetToken1() // private
  181. {
  182.     short    c;
  183.     
  184.         /* initialize token vars */
  185.     fClass = tokUnknown;
  186.     fParam = tokNoParam;
  187.  
  188.         /* get first token character, which may be a pushback from previous token */
  189.     if (fPushedChar != EOF) {
  190.         c = fPushedChar;
  191.         fPushedChar = EOF;
  192.         }
  193.     else 
  194.         c= GetOneChar();
  195.          
  196.     switch ( c ) {
  197.     
  198.         case EOF:
  199.             fClass = tokEOF;
  200.             fMajor = 0;
  201.             return;
  202.         case tokBreakInData:
  203.             fClass= tokEOF;
  204.             fMajor= tokBreakInData;
  205.             return;
  206.             
  207.         case '\r': //RETURN
  208.           if (fMinor == '\n') { // nettext /n/r data ...
  209.               fClass = tokDropchar;
  210.               fMajor = tokNull; 
  211.               fMinor = 0;  
  212.               return;
  213.             }
  214.            goto caseNewline;
  215.            
  216.         case '\n': //NEWLINE:
  217.           if (fMinor == '\r') { // msdos /r/n data ...
  218.               fClass = tokDropchar;
  219.               fMajor = tokNull; 
  220.               fMinor = 0;  
  221.               return;
  222.             }
  223.         caseNewline:
  224.             fClass = tokControl;
  225.             fMajor = tokNewline; //tokSpecialChar;
  226.             fMinor = c; //tokNewline;
  227.             return;
  228.              
  229.         default: 
  230.             fClass = tokText;
  231.             fMajor = c;
  232.             fMinor = c; // MapChar( c);
  233.             return; 
  234.             
  235.         }
  236. }
  237.  
  238.  
  239.  
  240. // static
  241. char* DRichprocess::gGenCharMap=  DRichprocess::ReadOutputMap("gen");
  242. char* DRichprocess::gSymCharMap=  DRichprocess::ReadOutputMap("sym");
  243.  
  244. char* DRichprocess::ReadOutputMap( char *file)
  245. {
  246. // from rtfmaps.h
  247. #ifdef WIN_MAC
  248. # define     genInMap  mac_gen_CharCode 
  249. # define     symInMap  mac_sym_CharCode 
  250. #else
  251. # define     genInMap  ansi_gen_CharCode 
  252. # define     symInMap  ansi_sym_CharCode 
  253. #endif
  254.     short *inMap, i, val;
  255.     char *outMap = (char*) MemNew( rtfSC_MaxChar*sizeof(char));
  256.     
  257.     if (*file == 's') inMap= symInMap;
  258.     else inMap= genInMap;
  259.  
  260.     for (i= 0; i<rtfSC_MaxChar; i++) outMap[i]= 0;
  261.     for (i= 255; i >= 0; i--) {
  262.         val= inMap[i];
  263.         if (val>=0 && val<rtfSC_MaxChar) outMap[val]= i;
  264.         }
  265.     return outMap;
  266. }
  267.  
  268.  
  269.  
  270. void DRichprocess::PutLitChar(short c)
  271. {
  272.     if (fTextSize >= fTextMax) {
  273.         fTextMax = fTextSize + 1024;
  274.         fText= (char*) MemMore( fText, fTextMax + 1);
  275.         }
  276.     fText[fTextSize++]= (char) c;
  277.     /* fText[fTextSize]= '\0'; */
  278. }
  279.  
  280. void DRichprocess::PutLitStr(char *s)
  281. {
  282.     long len = StrLen(s);
  283.     if (len + fTextSize >= fTextMax) {
  284.         fTextMax = fTextSize + len + 1024;
  285.         fText= (Nlm_CharPtr) MemMore( fText, fTextMax + 1);
  286.         }
  287.     Nlm_MemCopy( fText + fTextSize, s, len); /* +1 for nul */
  288.     fTextSize += len;
  289. }
  290.  
  291. void DRichprocess::PutLitCharWithStyle(short c)
  292. {
  293.     if (IsNewStyle()) StoreStyle(fOldStyleRec.style, FALSE);  
  294.     PutLitChar(c);
  295. }
  296.  
  297.  
  298.  
  299. void DRichprocess::PutStdChar( short stdCode)
  300. {
  301.     if (fOutMap) {
  302.         int och = fOutMap[stdCode];
  303.         if (och == rtfSC_nothing)    {  
  304.             char    buf[80];
  305.             sprintf(buf, "{{%s}}", RTFStdCharName(stdCode));
  306.             PutLitStr(buf);
  307.             }
  308.         else {
  309.             PutLitChar(och);
  310.             }
  311.         }
  312.     else {
  313.         PutLitChar(stdCode); 
  314.         }
  315. }
  316.  
  317.  
  318. void DRichprocess::PutStdCharWithStyle(short stdCode)
  319. {
  320.     if (IsNewStyle()) StoreStyle(fOldStyleRec.style, FALSE);  
  321.     PutStdChar(stdCode);
  322. }
  323.  
  324.  
  325. void DRichprocess::StoreStyle(DRichStyle& theStyle, Boolean force)
  326. {
  327.     if (force || fTextSize) {  
  328.         if (fStyleCount >= fStyleMax) {
  329.             fStyleMax  = fStyleCount + 10;
  330.             fStyleArray= (DRichStyle*) MemMore(fStyleArray, fStyleMax*sizeof(DRichStyle));
  331.             }
  332.     
  333.         theStyle.nextofs= fTextSize; //fLastTextSize;
  334.         //theStyle.textlen= fTextSize - fLastTextSize;
  335.         fLastTextSize= fTextSize;
  336.         if (!fFont) theStyle.font= GetNlmFont(); //x
  337.              
  338.         theStyle.last= FALSE; /* make sure... */
  339.         if (fStyleArray) fStyleArray[fStyleCount]= theStyle;
  340.         fStyleCount++; 
  341.          
  342.         //PutLitChar(chStyleTag);
  343.         }
  344.     fOldStyleRec= fStyleRec; /* gOldStyle= gStyle;  */
  345.     (void) GetNlmFont();          
  346.     NotNewStyle();
  347. }
  348.  
  349. void DRichprocess::StoreStyleObject(DStyleObject* sob, short width, short height)
  350. {
  351.     fStyleRec.style.ispict= true;
  352.     fStyleRec.style.pixwidth= width; 
  353.     fStyleRec.style.pixheight= height; 
  354.     fStyleRec.style.fObject= sob;
  355.     PutLitChar(' ');  
  356.     StoreStyle(fStyleRec.style, TRUE);
  357.     fStyleRec.style.fObject= NULL;
  358.     fStyleRec.style.pixwidth= 0; 
  359.     fStyleRec.style.pixheight= 0; 
  360.     fStyleRec.style.ispict= FALSE;
  361.     fStyleRec.style.ismap= FALSE;
  362.     fOldStyleRec= fStyleRec;
  363.     NewStyle();
  364.     //PutLitCharWithStyle(' ');
  365. }
  366.  
  367.  
  368. Boolean DRichprocess::IsNewStyle() 
  369. { 
  370. #if 1 //x
  371.     return fNewStyle; 
  372. #else
  373.     return TestNewStyle();
  374. #endif
  375. }
  376.  
  377. Boolean DRichprocess::TestNewStyle()
  378. {
  379.     fNewStyle = ( fOldStyleRec.fontname != fStyleRec.fontname 
  380.                     || fOldStyleRec.fontfamily != fStyleRec.fontfamily 
  381.                     || fOldStyleRec.fontsize != fStyleRec.fontsize 
  382.                     || fOldStyleRec.style.IsNotEqual( &fStyleRec.style)
  383.                     );
  384.     return fNewStyle;
  385. }
  386.  
  387.  
  388.  
  389. Nlm_FonT DRichprocess::GetNlmFont()
  390. {
  391. #if 1  //x
  392.         // GetFont is a time waster, cut down # of these calls !!
  393.     if (!fFont || IsNewStyle()) {
  394.         fFont= Nlm_GetFont( fStyleRec.fontname, fStyleRec.fontsize, 
  395.                     fStyleRec.style.bold, fStyleRec.style.italic, fStyleRec.style.underline != 0, 
  396.                     fStyleRec.fontfamily);
  397.         }
  398. #else
  399.         fFont= Nlm_GetFont( fStyleRec.fontname, fStyleRec.fontsize, 
  400.                     fStyleRec.style.bold, fStyleRec.style.italic, fStyleRec.style.underline != 0, 
  401.                     fStyleRec.fontfamily);
  402. #endif
  403.     fStyleRec.style.font= fFont;
  404.     fOldStyleRec= fStyleRec; 
  405.     NotNewStyle();
  406.     return fFont;
  407. }
  408.  
  409. void DRichprocess::PushStyle()
  410. {
  411.     if (fStyleStackSize<kMaxStyleStack) 
  412.         fStyleStack[fStyleStackSize++]= fStyleRec;
  413. }
  414.  
  415. void DRichprocess::PopStyle()
  416. {            
  417.     if (fStyleStackSize>0) 
  418.         fStyleRec= fStyleStack[--fStyleStackSize];
  419.     NewStyle();
  420. }
  421.  
  422.  
  423. void DRichprocess::DefaultParag()
  424. {
  425.     fParaFmt= fDefParaFmt;
  426. }
  427.  
  428. void DRichprocess::SetDefaultParag(DParagraph* theDefault)
  429. {
  430.     fDefParaFmt= *theDefault;
  431. }
  432.  
  433. void DRichprocess::DefaultStyle()
  434. {
  435.     fStyleRec= gDefaultStyle;
  436.     TestNewStyle();
  437. }
  438.  
  439.  
  440. void DRichprocess::NewParagraph()
  441. {
  442.     /* when new data forces use of new Dgg_ParData, 
  443.         append current text & para & col to growing doc */
  444. #if 1            
  445.     (void) GetNlmFont();  
  446.     StoreStyle( fStyleRec.style, TRUE);    /* gOldStyle */
  447.     //fTextSize--; /* unput last chStyleTag */
  448. #endif
  449.  
  450.     fStyleArray[fStyleCount-1].last= TRUE;
  451.     fText[fTextSize]= 0;
  452.     
  453.     fDoc->Append( fText, &fParaFmt, fStyleArray, fStyleCount);
  454.  
  455.     if (fProgress && fDataFile && (fParaCount % 10 == 0)) 
  456.         (void) Nlm_MonitorIntValue(fProgress, fDataFile->Tell());
  457.     fParaCount++;
  458.     fOldParaFmt= fParaFmt;
  459.     fParaFmt.numstops= fTextSize= fLastTextSize= fStyleCount= 0;
  460. }
  461.  
  462.  
  463.  
  464.  
  465.  
  466. void DRichprocess::handleUnknownClass()
  467. {
  468.     // nothing
  469. }
  470.  
  471. void DRichprocess::handleTextClass()
  472. {
  473.     if (IsNewStyle()) StoreStyle(fOldStyleRec.style, FALSE);  
  474.     PutLitChar(fMinor); 
  475.     fLastChar= fMajor;
  476. }
  477.  
  478. void DRichprocess::handleControlClass()
  479. {
  480.     switch (fMajor) {
  481.         
  482.         case tokNewline:
  483.             PutLitCharWithStyle ('\n');
  484.             NewParagraph();
  485.             break;
  486.  
  487.         default:
  488.             break;
  489.         }
  490.  
  491. }
  492.  
  493.  
  494.